{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas基础\n",
    "1. 数据结构简介：DataFrame和Series\n",
    "2. 数据索引index\n",
    "3. 利用pandas查询数据\n",
    "4. 利用pandas的DataFrames进行统计分析\n",
    "5. 利用pandas实现SQL操作\n",
    "6. 利用pandas进行缺失值的处理\n",
    "7. 利用pandas实现Excel的数据透视表功能\n",
    "8. 多层索引的使用\n",
    "\n",
    "参考链接： https://www.cnblogs.com/nxld/p/6058591.html\n",
    "\n",
    "https://tianchi.aliyun.com/notebook-ai/detail?spm=5176.12282042.0.0.1dce2042zuzard&postId=6068"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. 数据结构简介\n",
    "\n",
    "在pandas中有两类非常重要的数据结构，即序列Series和数据框DataFrame。Series类似于numpy中的一维数组，除了通吃一维数组可用的函数或方法，而且其可通过索引标签的方式获取数据，还具有索引的自动对齐功能；DataFrame类似于numpy中的二维数组，同样可以通用numpy数组的函数和方法，而且还具有其他灵活应用，后续会介绍到\n",
    "\n",
    "## 1.1 Series的创建\n",
    "\n",
    "序列的创建主要有三种方式\n",
    "\n",
    "**1）通过一维数组创建序列**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np, pandas as pd\n",
    "\n",
    "arr1 = np.arange(10)\n",
    "print(arr1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(type(arr1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    0\n",
      "1    1\n",
      "2    2\n",
      "3    3\n",
      "4    4\n",
      "5    5\n",
      "6    6\n",
      "7    7\n",
      "8    8\n",
      "9    9\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "s1 = pd.Series(arr1)\n",
    "print(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.series.Series'>\n"
     ]
    }
   ],
   "source": [
    "print(type(s1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2）通过字典的方式创建序列**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 10, 'b': 20, 'c': 30, 'd': 40, 'e': 50}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "dic1 = {'a':10,'b':20,'c':30,'d':40,'e':50}\n",
    "print(dic1)\n",
    "print(type(dic1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3）通过DataFrame中的某一行或某一列创建序列**\n",
    "\n",
    "## 1.2 DataFrame的创建\n",
    "\n",
    "数据框的创建主要有三种方式：\n",
    "\n",
    "1）通过二维数组创建数据框"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "arr2 = np.array(np.arange(12)).reshape(4,3)\n",
    "print(arr2)\n",
    "print(type(arr2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   0   1   2\n",
      "0  0   1   2\n",
      "1  3   4   5\n",
      "2  6   7   8\n",
      "3  9  10  11\n",
      "<class 'pandas.core.frame.DataFrame'>\n"
     ]
    }
   ],
   "source": [
    "df1 = pd.DataFrame(arr2)\n",
    "print(df1)\n",
    "print(type(df1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2）通过字典的方式创建数据框**\n",
    "\n",
    "以下以两种字典来创建数据框，一个是字典列表，一个是嵌套字典。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8], 'c': [9, 10, 11, 12], 'd': [13, 14, 15, 16]}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "dic2 = {'a':[1,2,3,4],'b':[5,6,7,8],'c':[9,10,11,12],'d':[13,14,15,16]}\n",
    "print(dic2)\n",
    "print(type(dic2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   a  b   c   d\n",
      "0  1  5   9  13\n",
      "1  2  6  10  14\n",
      "2  3  7  11  15\n",
      "3  4  8  12  16\n",
      "<class 'pandas.core.frame.DataFrame'>\n"
     ]
    }
   ],
   "source": [
    "df2 = pd.DataFrame(dic2)\n",
    "print(df2)\n",
    "print(type(df2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'one': {'a': 1, 'b': 2, 'c': 3, 'd': 4}, 'two': {'a': 5, 'b': 6, 'c': 7, 'd': 8}, 'three': {'a': 9, 'b': 10, 'c': 11, 'd': 12}}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "dic3 = {'one':{'a':1,'b':2,'c':3,'d':4},'two':{'a':5,'b':6,'c':7,'d':8},'three':{'a':9,'b':10,'c':11,'d':12}}\n",
    "print(dic3)\n",
    "print(type(dic3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   one  two  three\n",
      "a    1    5      9\n",
      "b    2    6     10\n",
      "c    3    7     11\n",
      "d    4    8     12\n",
      "<class 'pandas.core.frame.DataFrame'>\n"
     ]
    }
   ],
   "source": [
    "df3 = pd.DataFrame(dic3)\n",
    "print(df3)\n",
    "print(type(df3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3）通过数据框的方式创建数据框**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   one  three\n",
      "a    1      9\n",
      "b    2     10\n",
      "c    3     11\n",
      "d    4     12\n",
      "<class 'pandas.core.frame.DataFrame'>\n"
     ]
    }
   ],
   "source": [
    "df4 = df3[['one','three']]\n",
    "print(df4)\n",
    "print(type(df4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    1\n",
      "b    2\n",
      "c    3\n",
      "d    4\n",
      "Name: one, dtype: int64\n",
      "<class 'pandas.core.series.Series'>\n"
     ]
    }
   ],
   "source": [
    "s3 = df3['one']\n",
    "print(s3)\n",
    "print(type(s3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 数据索引index\n",
    "\n",
    "细致的朋友可能会发现一个现象，不论是序列也好，还是数据框也好，对象的最左边总有一个非原始数据对象，这个是什么呢？不错，就是我们接下来要介绍的索引。 在我看来，序列或数据框的索引有两大用处，一个是通过索引值或索引标签获取目标数据，另一个是通过索引，可以使序列或数据框的计算、操作实现自动化对齐，下面我们就来看看这两个功能的应用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 通过索引值或索引标签获取数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    1\n",
      "1    1\n",
      "2    2\n",
      "3    3\n",
      "4    5\n",
      "5    8\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "s4 = pd.Series(np.array([1,1,2,3,5,8]))\n",
    "print(s4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果不给序列一个指定的索引值，则序列自动生成一个从0开始的自增索引。可以通过index查看序列的索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RangeIndex(start=0, stop=6, step=1)\n"
     ]
    }
   ],
   "source": [
    "print(s4.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们为序列设定一个自定义的索引值：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    1\n",
      "b    1\n",
      "c    2\n",
      "d    3\n",
      "e    5\n",
      "f    8\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "s4.index = ['a','b','c','d','e','f']\n",
    "print(s4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "序列有了索引，就可以通过索引值或索引标签进行数据的获取：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s4[3]:  3\n",
      "s4[e]:  5\n",
      "s4[1,3,5]:  b    1\n",
      "d    3\n",
      "f    8\n",
      "dtype: int64\n",
      "s4[['a','b','d','f']]:  a    1\n",
      "b    1\n",
      "d    3\n",
      "f    8\n",
      "dtype: int64\n",
      "s4[:4]:  a    1\n",
      "b    1\n",
      "c    2\n",
      "d    3\n",
      "dtype: int64\n",
      "s4['c':]:  c    2\n",
      "d    3\n",
      "e    5\n",
      "f    8\n",
      "dtype: int64\n",
      "s4['b':'e']:  b    1\n",
      "c    2\n",
      "d    3\n",
      "e    5\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print('s4[3]: ',s4[3])\n",
    "print('s4[e]: ',s4['e'])\n",
    "print(\"s4[1,3,5]: \",s4[[1,3,5]])\n",
    "print(\"s4[['a','b','d','f']]: \",s4[['a','b','d','f']])\n",
    "print('s4[:4]: ',s4[:4])\n",
    "print(\"s4['c':]: \",s4['c':])\n",
    "print(\"s4['b':'e']: \",s4['b':'e'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 千万注意：如果通过索引标签获取数据的话，末端标签所对应的值是可以返回的！在一维数组中，就无法通过索引标签获取数据，这也是序列不同于一维数组的一个方面。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 自动化对齐\n",
    "\n",
    "如果有两个序列，需要对这两个序列进行算术运算，这时索引的存在就体现的它的价值了—自动化对齐.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    10\n",
      "b    15\n",
      "c    20\n",
      "d    30\n",
      "e    55\n",
      "f    80\n",
      "dtype: int64\n",
      "a    12\n",
      "c    11\n",
      "g    13\n",
      "b    15\n",
      "d    14\n",
      "f    16\n",
      "dtype: int64\n",
      "a    22.0\n",
      "b    30.0\n",
      "c    31.0\n",
      "d    44.0\n",
      "e     NaN\n",
      "f    96.0\n",
      "g     NaN\n",
      "dtype: float64\n",
      "a    0.833333\n",
      "b    1.000000\n",
      "c    1.818182\n",
      "d    2.142857\n",
      "e         NaN\n",
      "f    5.000000\n",
      "g         NaN\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "s5 = pd.Series(np.array([10,15,20,30,55,80]),index = ['a','b','c','d','e','f'])\n",
    "print(s5)\n",
    "\n",
    "s6 = pd.Series(np.array([12,11,13,15,14,16]),index = ['a','c','g','b','d','f'])\n",
    "print(s6)\n",
    "print(s5 + s6)\n",
    "print(s5/s6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于s5中没有对应的g索引，s6中没有对应的e索引，所以数据的运算会产生两个缺失值NaN。注意，这里的算术结果就实现了两个序列索引的自动对齐，而非简单的将两个序列加总或相除。对于数据框的对齐，不仅仅是行索引的自动对齐，同时也会自动对齐列索引（变量名）\n",
    "\n",
    "数据框中同样有索引，而且数据框是二维数组的推广，所以其不仅有行索引，而且还存在列索引，关于数据框中的索引相比于序列的应用要强大的多，这部分内容将放在数据查询中讲解\n",
    "\n",
    "# 3. 利用pandas查询数据\n",
    "\n",
    "这里的查询数据相当于R语言里的subset功能，可以通过布尔索引有针对的选取原数据的子集、指定行、指定列等。我们先导入一个student数据集\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "stu_dic = {'Age':[14,13,13,14,14,12,12,15,13,12,11,14,12,15,16,12,15,11,15],\n",
    "'Height':[69,56.5,65.3,62.8,63.5,57.3,59.8,62.5,62.5,59,51.3,64.3,56.3,66.5,72,64.8,67,57.5,66.5],\n",
    "'Name':['Alfred','Alice','Barbara','Carol','Henry','James','Jane','Janet','Jeffrey','John','Joyce','Judy','Louise','Marry','Philip','Robert','Ronald','Thomas','Willam'],\n",
    "'Sex':['M','F','F','F','M','M','F','F','M','M','F','F','F','F','M','M','M','M','M'],\n",
    "'Weight':[112.5,84,98,102.5,102.5,83,84.5,112.5,84,99.5,50.5,90,77,112,150,128,133,85,112]}\n",
    "student = pd.DataFrame(stu_dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查询数据的前5行或末尾5行\n",
    "\n",
    "student.head()\n",
    "\n",
    "student.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Age  Height     Name Sex  Weight\n",
      "0   14    69.0   Alfred   M   112.5\n",
      "1   13    56.5    Alice   F    84.0\n",
      "2   13    65.3  Barbara   F    98.0\n",
      "3   14    62.8    Carol   F   102.5\n",
      "4   14    63.5    Henry   M   102.5\n"
     ]
    }
   ],
   "source": [
    "print(student.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Age  Height    Name Sex  Weight\n",
      "14   16    72.0  Philip   M   150.0\n",
      "15   12    64.8  Robert   M   128.0\n",
      "16   15    67.0  Ronald   M   133.0\n",
      "17   11    57.5  Thomas   M    85.0\n",
      "18   15    66.5  Willam   M   112.0\n"
     ]
    }
   ],
   "source": [
    "print(student.tail())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**查询指定的行**\n",
    "\n",
    "student.loc[[0,2,4,5,7]] #这里的loc索引标签函数必须是中括号[]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Age  Height     Name Sex  Weight\n",
      "0   14    69.0   Alfred   M   112.5\n",
      "2   13    65.3  Barbara   F    98.0\n",
      "4   14    63.5    Henry   M   102.5\n",
      "5   12    57.3    James   M    83.0\n",
      "7   15    62.5    Janet   F   112.5\n"
     ]
    }
   ],
   "source": [
    "print(student.iloc[[0,2,4,5,7]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查询指定的列\n",
    "\n",
    "student[['Name','Height','Weight']].head() #如果多个列的话，必须使用双重中括号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Height  Weight\n",
      "0   Alfred    69.0   112.5\n",
      "1    Alice    56.5    84.0\n",
      "2  Barbara    65.3    98.0\n",
      "3    Carol    62.8   102.5\n",
      "4    Henry    63.5   102.5\n"
     ]
    }
   ],
   "source": [
    "print(student[['Name','Height','Weight']].head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**可以通过loc索引标签查询指定的列**\n",
    "\n",
    "student.loc[:,['Name','Height','Weight']].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Height  Weight\n",
      "0   Alfred    69.0   112.5\n",
      "1    Alice    56.5    84.0\n",
      "2  Barbara    65.3    98.0\n",
      "3    Carol    62.8   102.5\n",
      "4    Henry    63.5   102.5\n"
     ]
    }
   ],
   "source": [
    "print(student.loc[:,['Name','Height','Weight']].head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**查询出所有12岁以上的女生信息**\n",
    "\n",
    "student[(student['Sex']=='F') & (student['Age']>12)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Age  Height     Name Sex  Weight\n",
      "1    13    56.5    Alice   F    84.0\n",
      "2    13    65.3  Barbara   F    98.0\n",
      "3    14    62.8    Carol   F   102.5\n",
      "7    15    62.5    Janet   F   112.5\n",
      "11   14    64.3     Judy   F    90.0\n",
      "13   15    66.5    Marry   F   112.0\n"
     ]
    }
   ],
   "source": [
    "print(student[(student['Sex']=='F') & (student['Age']>12)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的查询逻辑其实非常的简单，需要注意的是，如果是多个条件的查询，必须在&（且）或者|（或）的两端条件用括号括起来。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. 利用pandas的DataFrames进行统计分析\n",
    "\n",
    "pandas模块为我们提供了非常多的描述性统计分析的指标函数，如总和、均值、最小值、最大值等，我们来具体看看这些函数： 首先随机生成三组数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "非空元素计算:  100\n",
      "最小值:  -4.1270333212494705\n",
      "最大值:  7.781921030926066\n",
      "最小值的位置:  81\n",
      "最大值的位置:  39\n",
      "10%分位数:  0.6870184644069928\n",
      "求和:  307.0224566250873\n",
      "均值:  3.070224566250874\n",
      "中位数:  3.204555266776845\n",
      "众数:  0    -4.127033\n",
      "1    -1.800907\n",
      "2    -1.485370\n",
      "3    -1.149955\n",
      "4    -1.042510\n",
      "5    -0.634054\n",
      "6    -0.093811\n",
      "7     0.108380\n",
      "8     0.196053\n",
      "9     0.618049\n",
      "10    0.694682\n",
      "11    0.714737\n",
      "12    0.862022\n",
      "13    0.944299\n",
      "14    1.051527\n",
      "15    1.147491\n",
      "16    1.205686\n",
      "17    1.429130\n",
      "18    1.558823\n",
      "19    1.688061\n",
      "20    1.726953\n",
      "21    1.830564\n",
      "22    1.867108\n",
      "23    1.903515\n",
      "24    1.976237\n",
      "25    2.061389\n",
      "26    2.139809\n",
      "27    2.200071\n",
      "28    2.204320\n",
      "29    2.310468\n",
      "        ...   \n",
      "70    4.131477\n",
      "71    4.263959\n",
      "72    4.351108\n",
      "73    4.408456\n",
      "74    4.409441\n",
      "75    4.510828\n",
      "76    4.534737\n",
      "77    4.633188\n",
      "78    4.682018\n",
      "79    4.683349\n",
      "80    4.719177\n",
      "81    4.727435\n",
      "82    4.774326\n",
      "83    4.906648\n",
      "84    4.969840\n",
      "85    4.983892\n",
      "86    5.067601\n",
      "87    5.091877\n",
      "88    5.095157\n",
      "89    5.117938\n",
      "90    5.300071\n",
      "91    5.636303\n",
      "92    5.642211\n",
      "93    5.642316\n",
      "94    5.783972\n",
      "95    5.865414\n",
      "96    6.091318\n",
      "97    7.015686\n",
      "98    7.061207\n",
      "99    7.781921\n",
      "Length: 100, dtype: float64\n",
      "方差:  4.005609378535085\n",
      "标准差:  2.0014018533355777\n",
      "平均绝对偏差:  1.5112880411556109\n",
      "偏度:  -0.6494780760484293\n",
      "峰度:  1.2201094052398012\n",
      "描述性统计指标:  count    100.000000\n",
      "mean       3.070225\n",
      "std        2.001402\n",
      "min       -4.127033\n",
      "25%        2.040101\n",
      "50%        3.204555\n",
      "75%        4.434788\n",
      "max        7.781921\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(1234)\n",
    "d1 = pd.Series(2*np.random.normal(size = 100)+3)\n",
    "d2 = np.random.f(2,4,size = 100)\n",
    "d3 = np.random.randint(1,100,size = 100)\n",
    "\n",
    "print('非空元素计算: ', d1.count()) #非空元素计算\n",
    "print('最小值: ', d1.min()) #最小值\n",
    "print('最大值: ', d1.max()) #最大值\n",
    "print('最小值的位置: ', d1.idxmin()) #最小值的位置，类似于R中的which.min函数\n",
    "print('最大值的位置: ', d1.idxmax()) #最大值的位置，类似于R中的which.max函数\n",
    "print('10%分位数: ', d1.quantile(0.1)) #10%分位数\n",
    "print('求和: ', d1.sum()) #求和\n",
    "print('均值: ', d1.mean()) #均值\n",
    "print('中位数: ', d1.median()) #中位数\n",
    "print('众数: ', d1.mode()) #众数\n",
    "print('方差: ', d1.var()) #方差\n",
    "print('标准差: ', d1.std()) #标准差\n",
    "print('平均绝对偏差: ', d1.mad()) #平均绝对偏差\n",
    "print('偏度: ', d1.skew()) #偏度\n",
    "print('峰度: ', d1.kurt()) #峰度\n",
    "print('描述性统计指标: ', d1.describe()) #一次性输出多个描述性统计指标"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "必须注意的是，descirbe方法只能针对序列或数据框，一维数组是没有这个方法的\n",
    "\n",
    "这里自定义一个函数，将这些统计描述指标全部汇总到一起:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count        100.000000\n",
      "Min           -4.127033\n",
      "Whicn_Min     81.000000\n",
      "Q1             2.040101\n",
      "Median         3.204555\n",
      "Q3             4.434788\n",
      "Mean           3.070225\n",
      "Max            7.781921\n",
      "Which_Max     39.000000\n",
      "Mad            1.511288\n",
      "Var            4.005609\n",
      "Std            2.001402\n",
      "Skew          -0.649478\n",
      "Kurt           1.220109\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "def stats(x):\n",
    "\treturn pd.Series([x.count(),x.min(),x.idxmin(),x.quantile(.25),x.median(),x.quantile(.75),\n",
    "                      x.mean(),x.max(),x.idxmax(),x.mad(),x.var(),x.std(),x.skew(),x.kurt()],\n",
    "                     index = ['Count','Min','Whicn_Min','Q1','Median','Q3','Mean','Max',\n",
    "                              'Which_Max','Mad','Var','Std','Skew','Kurt'])\n",
    "print(stats(d1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在实际的工作中，我们可能需要处理的是一系列的数值型数据框，如何将这个函数应用到数据框中的每一列呢？可以使用apply函数，这个非常类似于R中的apply的应用方法。 将之前创建的d1,d2,d3数据构建数据框:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         x1        x2    x3\n",
      "0  3.942870  1.369531  55.0\n",
      "1  0.618049  0.943264  68.0\n",
      "2  5.865414  0.590663  73.0\n",
      "3  2.374696  0.206548  59.0\n",
      "4  1.558823  0.223204  60.0\n"
     ]
    }
   ],
   "source": [
    "df = pd.DataFrame(np.array([d1,d2,d3]).T,columns=['x1','x2','x3'])\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                   x1          x2          x3\n",
      "Count      100.000000  100.000000  100.000000\n",
      "Min         -4.127033    0.014330    3.000000\n",
      "Whicn_Min   81.000000   72.000000   76.000000\n",
      "Q1           2.040101    0.249580   25.000000\n",
      "Median       3.204555    1.000613   54.500000\n",
      "Q3           4.434788    2.101581   73.000000\n",
      "Mean         3.070225    2.028608   51.490000\n",
      "Max          7.781921   18.791565   98.000000\n",
      "Which_Max   39.000000   53.000000   96.000000\n",
      "Mad          1.511288    1.922669   24.010800\n",
      "Var          4.005609   10.206447  780.090808\n",
      "Std          2.001402    3.194753   27.930106\n",
      "Skew        -0.649478    3.326246   -0.118917\n",
      "Kurt         1.220109   12.636286   -1.211579\n"
     ]
    }
   ],
   "source": [
    "print(df.apply(stats))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "非常完美，就这样很简单的创建了数值型数据的统计性描述。如果是离散型数据呢？就不能用这个统计口径了，我们需要统计离散变量的观测数、唯一值个数、众数水平及个数。你只需要使用describe方法就可以实现这样的统计了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count     19\n",
      "unique     2\n",
      "top        M\n",
      "freq      10\n",
      "Name: Sex, dtype: object\n"
     ]
    }
   ],
   "source": [
    "print(student['Sex'].describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除以上的简单描述性统计之外，还提供了连续变量的相关系数（corr）和协方差矩阵（cov）的求解，这个跟R语言是一致的用法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          x1        x2        x3\n",
      "x1  1.000000  0.136085  0.037185\n",
      "x2  0.136085  1.000000 -0.005688\n",
      "x3  0.037185 -0.005688  1.000000\n"
     ]
    }
   ],
   "source": [
    "print(df.corr())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "关于相关系数的计算可以调用pearson方法或kendell方法或spearman方法，默认使用pearson方法。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         x1        x2        x3\n",
      "x1  1.00000  0.178950  0.006590\n",
      "x2  0.17895  1.000000 -0.033874\n",
      "x3  0.00659 -0.033874  1.000000\n"
     ]
    }
   ],
   "source": [
    "print(df.corr('spearman'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1    1.000000\n",
      "x2    0.136085\n",
      "x3    0.037185\n",
      "dtype: float64\n",
      "          x1         x2          x3\n",
      "x1  4.005609   0.870124    2.078596\n",
      "x2  0.870124  10.206447   -0.507512\n",
      "x3  2.078596  -0.507512  780.090808\n"
     ]
    }
   ],
   "source": [
    "# 如果只想关注某一个变量与其余变量的相关系数的话，可以使用corrwith,如下方只关心x1与其余变量的相关系数:\n",
    "print(df.corrwith(df['x1']))\n",
    "# 数值型变量间的协方差矩阵\n",
    "print(df.cov())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. 利用pandas实现SQL操作\n",
    "\n",
    "在SQL中常见的操作主要是增、删、改、查几个动作，那么pandas能否实现对数据的这几项操作呢？答案是Of Course!\n",
    "\n",
    "**增：添加新行或增加新列**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           Name Sex  Age  Height  Weight\n",
      "0  LiuShunxiang   M   27   165.7      61\n",
      "1     Zhangshan   F   23   167.2      63\n"
     ]
    }
   ],
   "source": [
    "dic = {'Name':['LiuShunxiang','Zhangshan'],'Sex':['M','F'],'Age':[27,23],'Height':[165.7,167.2],'Weight':[61,63]}\n",
    "student2 = pd.DataFrame(dic)\n",
    "print(student2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在将student2中的数据新增到student中，可以通过concat函数实现：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Age  Height          Name Sex  Weight\n",
      "0    14    69.0        Alfred   M   112.5\n",
      "1    13    56.5         Alice   F    84.0\n",
      "2    13    65.3       Barbara   F    98.0\n",
      "3    14    62.8         Carol   F   102.5\n",
      "4    14    63.5         Henry   M   102.5\n",
      "5    12    57.3         James   M    83.0\n",
      "6    12    59.8          Jane   F    84.5\n",
      "7    15    62.5         Janet   F   112.5\n",
      "8    13    62.5       Jeffrey   M    84.0\n",
      "9    12    59.0          John   M    99.5\n",
      "10   11    51.3         Joyce   F    50.5\n",
      "11   14    64.3          Judy   F    90.0\n",
      "12   12    56.3        Louise   F    77.0\n",
      "13   15    66.5         Marry   F   112.0\n",
      "14   16    72.0        Philip   M   150.0\n",
      "15   12    64.8        Robert   M   128.0\n",
      "16   15    67.0        Ronald   M   133.0\n",
      "17   11    57.5        Thomas   M    85.0\n",
      "18   15    66.5        Willam   M   112.0\n",
      "0    27   165.7  LiuShunxiang   M    61.0\n",
      "1    23   167.2     Zhangshan   F    63.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/louis/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=False'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass 'sort=True'.\n",
      "\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "student3 = pd.concat([student,student2])\n",
    "print(student3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意到了吗？在数据库中union必须要求两张表的列顺序一致，而这里concat函数可以自动对齐两个数据框的变量！\n",
    "\n",
    "新增列的话，其实在pandas中就更简单了，例如在student2中新增一列学生成绩："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Age  Height          Name Sex  Weight  Score\n",
      "0   27   165.7  LiuShunxiang   M      61    NaN\n",
      "1   23   167.2     Zhangshan   F      63    NaN\n"
     ]
    }
   ],
   "source": [
    "print(pd.DataFrame(student2, columns=['Age','Height','Name','Sex','Weight','Score']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于新增的列没有赋值，就会出现空NaN的形式。\n",
    "\n",
    "删：删除表、观测行或变量列\n",
    "删除数据框student2,通过del命令实现，该命令可以删除Python的所有对象。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'student2' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-37-3453d237c14b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mstudent2\u001b[0m \u001b[0;31m#删除数据框student2, 通过del命令可以删除python的所有对象\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstudent2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'student2' is not defined"
     ]
    }
   ],
   "source": [
    "del student2 #删除数据框student2, 通过del命令可以删除python的所有对象\n",
    "print(student2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Age  Height     Name Sex  Weight\n",
      "2    13    65.3  Barbara   F    98.0\n",
      "4    14    63.5    Henry   M   102.5\n",
      "5    12    57.3    James   M    83.0\n",
      "7    15    62.5    Janet   F   112.5\n",
      "8    13    62.5  Jeffrey   M    84.0\n",
      "9    12    59.0     John   M    99.5\n",
      "10   11    51.3    Joyce   F    50.5\n",
      "11   14    64.3     Judy   F    90.0\n",
      "12   12    56.3   Louise   F    77.0\n",
      "13   15    66.5    Marry   F   112.0\n",
      "14   16    72.0   Philip   M   150.0\n",
      "15   12    64.8   Robert   M   128.0\n",
      "16   15    67.0   Ronald   M   133.0\n",
      "17   11    57.5   Thomas   M    85.0\n",
      "18   15    66.5   Willam   M   112.0\n"
     ]
    }
   ],
   "source": [
    "print(student.drop([0,1,3,6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "原数据中的第1,2,4,7行的数据已经被删除了。\n",
    "\n",
    "根据布尔索引删除行数据，其实这个删除就是保留删除条件的反面数据，例如删除所有14岁以下的学生：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Age  Height    Name Sex  Weight\n",
      "7    15    62.5   Janet   F   112.5\n",
      "13   15    66.5   Marry   F   112.0\n",
      "14   16    72.0  Philip   M   150.0\n",
      "16   15    67.0  Ronald   M   133.0\n",
      "18   15    66.5  Willam   M   112.0\n"
     ]
    }
   ],
   "source": [
    "print(student[student['Age']>14])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Age     Name Sex\n",
      "0   14   Alfred   M\n",
      "1   13    Alice   F\n",
      "2   13  Barbara   F\n",
      "3   14    Carol   F\n",
      "4   14    Henry   M\n"
     ]
    }
   ],
   "source": [
    "print(student.drop(['Height','Weight'],axis=1).head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们发现，不论是删除行还是删除列，都可以通过drop方法实现，只需要设定好删除的轴即可，即调整drop方法中的axis参数。默认该参数为0，表示删除行观测，如果需要删除列变量，则需设置为1。\n",
    "\n",
    "**改：修改原始记录的值**\n",
    "\n",
    "如果发现表中的某些数据错误了，如何更改原来的值呢？我们试试结合布尔索引和赋值的方法： 例如发现student3中姓名为LiuShunxiang的学生身高错了，应该是173，如何改呢？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           Name  Height\n",
      "0  LiuShunxiang   173.0\n"
     ]
    }
   ],
   "source": [
    "student3.loc[student3['Name'] == 'LiuShunxiang','Height']=173\n",
    "print(student3[student3['Name'] == 'LiuShunxiang'][['Name','Height']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这样就可以把原来的身高修改为现在的170了。 看，关于索引的操作非常灵活、方便吧，就这样轻松搞定数据的更改。\n",
    "\n",
    "**查：有关数据查询部分，上面已经介绍过**\n",
    "\n",
    "下面重点讲讲聚合、排序和多表连接操作。\n",
    "\n",
    "**聚合：pandas模块中可以通过groupby()函数实现数据的聚合操作**\n",
    "\n",
    "根据性别分组，计算各组别中学生身高和体重的平均值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           Age     Height      Weight\n",
      "Sex                                  \n",
      "F    13.222222  60.588889   90.111111\n",
      "M    13.400000  63.910000  108.950000\n"
     ]
    }
   ],
   "source": [
    "print(student.groupby('Sex').mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果不对原始数据作限制的话，聚合函数会自动选择数值型数据进行聚合计算。如果不想对年龄计算平均值的话，就需要剔除改变量："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Height      Weight\n",
      "Sex                       \n",
      "F    60.588889   90.111111\n",
      "M    63.910000  108.950000\n"
     ]
    }
   ],
   "source": [
    "print(student.drop('Age',axis=1).groupby('Sex').mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "groupby还可以使用多个分组变量，例如根本年龄和性别分组，计算身高与体重的平均值：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            Height  Weight\n",
      "Sex Age                   \n",
      "F   11   51.300000   50.50\n",
      "    12   58.050000   80.75\n",
      "    13   60.900000   91.00\n",
      "    14   63.550000   96.25\n",
      "    15   64.500000  112.25\n",
      "M   11   57.500000   85.00\n",
      "    12   60.366667  103.50\n",
      "    13   62.500000   84.00\n",
      "    14   66.250000  107.50\n",
      "    15   66.750000  122.50\n",
      "    16   72.000000  150.00\n"
     ]
    }
   ],
   "source": [
    "print(student.groupby(['Sex','Age']).mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，还可以对每个分组计算多个统计量：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Height             Weight        \n",
      "          mean median        mean  median\n",
      "Sex                                      \n",
      "F    60.588889  62.50   90.111111   90.00\n",
      "M    63.910000  64.15  108.950000  107.25\n"
     ]
    }
   ],
   "source": [
    "print(student.drop('Age',axis=1).groupby('Sex').agg([np.mean,np.median]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**排序：**\n",
    "\n",
    "排序在日常的统计分析中还是比较常见的操作，我们可以使用sort_index和sort_values实现序列和数据框的排序工作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    18\n",
      "1    15\n",
      "2    16\n",
      "3    18\n",
      "4    16\n",
      "5     8\n",
      "6    17\n",
      "7    10\n",
      "8    16\n",
      "9     6\n",
      "dtype: int64\n",
      "0    18\n",
      "1    15\n",
      "2    16\n",
      "3    18\n",
      "4    16\n",
      "5     8\n",
      "6    17\n",
      "7    10\n",
      "8    16\n",
      "9     6\n",
      "dtype: int64\n",
      "3    18\n",
      "0    18\n",
      "6    17\n",
      "8    16\n",
      "4    16\n",
      "2    16\n",
      "1    15\n",
      "7    10\n",
      "5     8\n",
      "9     6\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "Data = pd.Series(np.array(np.random.randint(1,20,10)))\n",
    "print(Data)\n",
    "print(Data.sort_index())\n",
    "print(Data.sort_values(ascending=False))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在数据框中一般都是按值排序，\n",
    "例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Age  Height     Name Sex  Weight\n",
      "10   11    51.3    Joyce   F    50.5\n",
      "17   11    57.5   Thomas   M    85.0\n",
      "12   12    56.3   Louise   F    77.0\n",
      "5    12    57.3    James   M    83.0\n",
      "9    12    59.0     John   M    99.5\n",
      "6    12    59.8     Jane   F    84.5\n",
      "15   12    64.8   Robert   M   128.0\n",
      "1    13    56.5    Alice   F    84.0\n",
      "8    13    62.5  Jeffrey   M    84.0\n",
      "2    13    65.3  Barbara   F    98.0\n",
      "3    14    62.8    Carol   F   102.5\n",
      "4    14    63.5    Henry   M   102.5\n",
      "11   14    64.3     Judy   F    90.0\n",
      "0    14    69.0   Alfred   M   112.5\n",
      "7    15    62.5    Janet   F   112.5\n",
      "13   15    66.5    Marry   F   112.0\n",
      "18   15    66.5   Willam   M   112.0\n",
      "16   15    67.0   Ronald   M   133.0\n",
      "14   16    72.0   Philip   M   150.0\n"
     ]
    }
   ],
   "source": [
    "print(student.sort_values(by = ['Age','Height']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**多表连接:**\n",
    "\n",
    "多表之间的连接也是非常常见的数据库操作，连接分内连接和外连接，在数据库语言中通过join关键字实现，pandas我比较建议使用merger函数实现数据的各种连接操作。 如下是构造一张学生的成绩表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Score\n",
      "0   Alfred     88\n",
      "1    Alice     76\n",
      "2  Barbara     89\n",
      "3    Carol     67\n",
      "4    Henry     79\n",
      "5  Jeffrey     90\n",
      "6     Judy     92\n",
      "7   Philip     86\n",
      "8   Robert     73\n",
      "9   Willam     77\n"
     ]
    }
   ],
   "source": [
    "dic2 = {'Name':['Alfred','Alice','Barbara','Carol','Henry','Jeffrey','Judy','Philip','Robert','Willam'],\n",
    "        'Score':[88,76,89,67,79,90,92,86,73,77]}\n",
    "score = pd.DataFrame(dic2)\n",
    "\n",
    "print(score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在想把学生表student与学生成绩表score做一个关联，该如何操作呢？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Age  Height     Name Sex  Weight  Score\n",
      "0   14    69.0   Alfred   M   112.5     88\n",
      "1   13    56.5    Alice   F    84.0     76\n",
      "2   13    65.3  Barbara   F    98.0     89\n",
      "3   14    62.8    Carol   F   102.5     67\n",
      "4   14    63.5    Henry   M   102.5     79\n",
      "5   13    62.5  Jeffrey   M    84.0     90\n",
      "6   14    64.3     Judy   F    90.0     92\n",
      "7   16    72.0   Philip   M   150.0     86\n",
      "8   12    64.8   Robert   M   128.0     73\n",
      "9   15    66.5   Willam   M   112.0     77\n"
     ]
    }
   ],
   "source": [
    "stu_score1 = pd.merge(student, score, on='Name')\n",
    "print(stu_score1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意，默认情况下，merge函数实现的是两个表之间的内连接，即返回两张表中共同部分的数据。可以通过how参数设置连接的方式，left为左连接；right为右连接；outer为外连接。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Age  Height     Name Sex  Weight  Score\n",
      "0    14    69.0   Alfred   M   112.5   88.0\n",
      "1    13    56.5    Alice   F    84.0   76.0\n",
      "2    13    65.3  Barbara   F    98.0   89.0\n",
      "3    14    62.8    Carol   F   102.5   67.0\n",
      "4    14    63.5    Henry   M   102.5   79.0\n",
      "5    12    57.3    James   M    83.0    NaN\n",
      "6    12    59.8     Jane   F    84.5    NaN\n",
      "7    15    62.5    Janet   F   112.5    NaN\n",
      "8    13    62.5  Jeffrey   M    84.0   90.0\n",
      "9    12    59.0     John   M    99.5    NaN\n",
      "10   11    51.3    Joyce   F    50.5    NaN\n",
      "11   14    64.3     Judy   F    90.0   92.0\n",
      "12   12    56.3   Louise   F    77.0    NaN\n",
      "13   15    66.5    Marry   F   112.0    NaN\n",
      "14   16    72.0   Philip   M   150.0   86.0\n",
      "15   12    64.8   Robert   M   128.0   73.0\n",
      "16   15    67.0   Ronald   M   133.0    NaN\n",
      "17   11    57.5   Thomas   M    85.0    NaN\n",
      "18   15    66.5   Willam   M   112.0   77.0\n"
     ]
    }
   ],
   "source": [
    "stu_score2 = pd.merge(student, score, on='Name', how='left')\n",
    "print(stu_score2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "左连接实现的是保留student表中的所有信息，同时将score表的信息与之配对，能配多少配多少，对于没有配对上的Name，将会显示成绩为NaN。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 利用pandas进行缺失值的处理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现实生活中的数据是非常杂乱的，其中缺失值也是非常常见的，对于缺失值的存在可能会影响到后期的数据分析或挖掘工作，那么我们该如何处理这些缺失值呢？\n",
    "\n",
    "常用的有三大类方法，即删除法、填补法和插值法。\n",
    "\n",
    "- 删除法：当数据中的某个变量大部分值都是缺失值，可以考虑删除改变量；当缺失值是随机分布的，且缺失的数量并不是很多是，也可以删除这些缺失的观测。\n",
    "- 替补法：对于连续型变量，如果变量的分布近似或就是正态分布的话，可以用均值替代那些缺失值；如果变量是有偏的，可以使用中位数来代替那些缺失值；对于离散型变量，我们一般用众数去替换那些存在缺失的观测。\n",
    "- 插补法：插补法是基于蒙特卡洛模拟法，结合线性模型、广义线性模型、决策树等方法计算出来的预测值替换缺失值。\n",
    "\n",
    "我们这里就介绍简单的删除法和替补法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     88.0\n",
      "1     76.0\n",
      "2     89.0\n",
      "3     67.0\n",
      "4     79.0\n",
      "5      NaN\n",
      "6      NaN\n",
      "7      NaN\n",
      "8     90.0\n",
      "9      NaN\n",
      "10     NaN\n",
      "11    92.0\n",
      "12     NaN\n",
      "13     NaN\n",
      "14    86.0\n",
      "15    73.0\n",
      "16     NaN\n",
      "17     NaN\n",
      "18    77.0\n",
      "Name: Score, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "s = stu_score2['Score']\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这是一组含有缺失值的序列，我们可以结合sum函数和isnull函数来检测数据中含有多少缺失值：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "print(sum(pd.isnull(s)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "直接删除缺失值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     88.0\n",
      "1     76.0\n",
      "2     89.0\n",
      "3     67.0\n",
      "4     79.0\n",
      "8     90.0\n",
      "11    92.0\n",
      "14    86.0\n",
      "15    73.0\n",
      "18    77.0\n",
      "Name: Score, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(s.dropna())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "默认情况下，dropna会删除任何含有缺失值的行，我们再构造一个数据框试试：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     x1    x2    x3\n",
      "0   1.0   1.0   2.0\n",
      "1   3.0   5.0   NaN\n",
      "2  13.0  21.0  34.0\n",
      "3  55.0   NaN  10.0\n",
      "4   NaN   NaN   NaN\n",
      "5   NaN   1.0   2.0\n",
      "     x1    x2    x3\n",
      "0   1.0   1.0   2.0\n",
      "2  13.0  21.0  34.0\n"
     ]
    }
   ],
   "source": [
    "df = pd.DataFrame([[1,1,2],[3,5,np.nan],[13,21,34],[55,np.nan,10],[np.nan,np.nan,np.nan],[np.nan,1,2]],columns=('x1','x2','x3'))\n",
    "print(df)\n",
    "print(df.dropna())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "返回结果表明，数据中只要含有缺失值NaN,该数据行就会被删除，如果使用参数how=’all’，则表明只删除所有行为缺失值的观测;\n",
    "\n",
    "使用一个常量来填补缺失值，可以使用fillna函数实现简单的填补工作：\n",
    "\n",
    "**用0填补所有缺失值**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     x1    x2    x3\n",
      "0   1.0   1.0   2.0\n",
      "1   3.0   5.0   0.0\n",
      "2  13.0  21.0  34.0\n",
      "3  55.0   0.0  10.0\n",
      "4   0.0   0.0   0.0\n",
      "5   0.0   1.0   2.0\n"
     ]
    }
   ],
   "source": [
    "print(df.fillna(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2)采用前项填充或后向填充**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     x1    x2    x3\n",
      "0   1.0   1.0   2.0\n",
      "1   3.0   5.0   2.0\n",
      "2  13.0  21.0  34.0\n",
      "3  55.0  21.0  10.0\n",
      "4  55.0  21.0  10.0\n",
      "5  55.0   1.0   2.0\n",
      "     x1    x2    x3\n",
      "0   1.0   1.0   2.0\n",
      "1   3.0   5.0  34.0\n",
      "2  13.0  21.0  34.0\n",
      "3  55.0   1.0  10.0\n",
      "4   NaN   1.0   2.0\n",
      "5   NaN   1.0   2.0\n"
     ]
    }
   ],
   "source": [
    "print(df.fillna(method='ffill'))\n",
    "print(df.fillna(method='bfill'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3)使用常量填充不同的列**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     x1    x2    x3\n",
      "0   1.0   1.0   2.0\n",
      "1   3.0   5.0   3.0\n",
      "2  13.0  21.0  34.0\n",
      "3  55.0   2.0  10.0\n",
      "4   1.0   2.0   3.0\n",
      "5   1.0   1.0   2.0\n"
     ]
    }
   ],
   "source": [
    "print(df.fillna({'x1':1,'x2':2,'x3':3}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.0\n",
      "7.0\n",
      "12.0\n",
      "     x1    x2    x3\n",
      "0   1.0   1.0   2.0\n",
      "1   3.0   5.0  12.0\n",
      "2  13.0  21.0  34.0\n",
      "3  55.0   7.0  10.0\n",
      "4   8.0   7.0  12.0\n",
      "5   8.0   1.0   2.0\n"
     ]
    }
   ],
   "source": [
    "x1_median=df['x1'].median()\n",
    "x2_mean=df['x2'].mean()\n",
    "x3_mean=df['x3'].mean()\n",
    "\n",
    "print(x1_median)\n",
    "print(x2_mean)\n",
    "print(x3_mean)\n",
    "print(df.fillna({'x1':x1_median,'x2':x2_mean,'x3':x3_mean}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "很显然，在使用填充法时，相对于常数填充或前项、后项填充，使用各列的众数、均值或中位数填充要更加合理一点，这也是工作中常用的一个快捷手段"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. 利用pandas实现Excel的数据透视表功能\n",
    "\n",
    "在Excel中有一个非常强大的功能就是数据透视表，通过托拉拽的方式可以迅速的查看数据的聚合情况，这里的聚合可以是计数、求和、均值、标准差等。 pandas为我们提供了非常强大的函数pivot_table()，该函数就是实现数据透视表功能的。对于上面所说的一些聚合函数，可以通过参数aggfunc设定。我们先看看这个函数的语法和参数吧：\n",
    "\n",
    "```\n",
    "pivot_table(data,values=None,\n",
    "            index=None,\n",
    "            columns=None,\n",
    "            aggfunc='mean',\n",
    "            fill_value=None,\n",
    "            margins=False,\n",
    "            dropna=True,\n",
    "            margins_name='All')  \n",
    "```\n",
    "\n",
    "data：需要进行数据透视表操作的数据框\n",
    "values：指定需要聚合的字段\n",
    "index：指定某些原始变量作为行索引\n",
    "columns：指定哪些离散的分组变量\n",
    "aggfunc：指定相应的聚合函数\n",
    "fill_value：使用一个常数替代缺失值，默认不替换\n",
    "margins：是否进行行或列的汇总，默认不汇总\n",
    "dropna：默认所有观测为缺失的列\n",
    "margins_name：默认行汇总或列汇总的名称为'All'\n",
    "\n",
    "我们仍然以student表为例，来认识一下数据透视表pivot_table函数的用法： 对一个分组变量（Sex），一个数值变量（Height）作统计汇总"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sex             F      M\n",
      "Height  60.588889  63.91\n"
     ]
    }
   ],
   "source": [
    "Table1 = pd.pivot_table(student, values=['Height'], columns=['Sex'])\n",
    "print(Table1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对一个分组变量（Sex），两个数值变量（Height,Weight）作统计汇总"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sex             F       M\n",
      "Height  60.588889   63.91\n",
      "Weight  90.111111  108.95\n"
     ]
    }
   ],
   "source": [
    "Table2 = pd.pivot_table(student, values=['Height','Weight'], columns=['Sex'])\n",
    "print(Table2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对两个分组变量（Sex，Age)，两个数值变量（Height,Weight）作统计汇总"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Sex  Age\n",
      "Height  F    11      51.300000\n",
      "             12      58.050000\n",
      "             13      60.900000\n",
      "             14      63.550000\n",
      "             15      64.500000\n",
      "        M    11      57.500000\n",
      "             12      60.366667\n",
      "             13      62.500000\n",
      "             14      66.250000\n",
      "             15      66.750000\n",
      "             16      72.000000\n",
      "Weight  F    11      50.500000\n",
      "             12      80.750000\n",
      "             13      91.000000\n",
      "             14      96.250000\n",
      "             15     112.250000\n",
      "        M    11      85.000000\n",
      "             12     103.500000\n",
      "             13      84.000000\n",
      "             14     107.500000\n",
      "             15     122.500000\n",
      "             16     150.000000\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "Table3 = pd.pivot_table(student, values=['Height','Weight'], columns=['Sex','Age'])\n",
    "print(Table3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "很显然这样的结果并不像Excel中预期的那样，该如何变成列联表的形式的？很简单，只需将结果进行非堆叠操作（unstack）即可："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age           11          12    13      14      15     16\n",
      "       Sex                                               \n",
      "Height F    51.3   58.050000  60.9   63.55   64.50    NaN\n",
      "       M    57.5   60.366667  62.5   66.25   66.75   72.0\n",
      "Weight F    50.5   80.750000  91.0   96.25  112.25    NaN\n",
      "       M    85.0  103.500000  84.0  107.50  122.50  150.0\n"
     ]
    }
   ],
   "source": [
    "Table4 = pd.pivot_table(student, values=['Height','Weight'], columns=['Sex','Age']).unstack()\n",
    "print(Table4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** 使用多个聚合函数 **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             mean         median                std           \n",
      "Sex             F       M      F       M          F          M\n",
      "Height  60.588889   63.91   62.5   64.15   5.018328   4.937937\n",
      "Weight  90.111111  108.95   90.0  107.25  19.383914  22.727186\n"
     ]
    }
   ],
   "source": [
    "Table5 = pd.pivot_table(student, values=['Height','Weight'], columns=['Sex'],aggfunc=[np.mean,np.median,np.std])\n",
    "print(Table5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有关更多数据透视表的操作，可参考《Pandas透视表（pivot_table）详解》一文，链接地址：http://python.jobbole.com/81212/\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. 多层索引的使用"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后我们再来讲讲pandas中的一个重要功能，那就是多层索引。在序列中它可以实现在一个轴上拥有多个索引，就类似于Excel中常见的这种形式：\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "对于这样的数据格式有什么好处呢？pandas可以帮我们实现用低维度形式处理高维数数据，这里举个例子也许你就能明白了："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a  1    1\n",
      "   2    2\n",
      "   3    3\n",
      "b  1    4\n",
      "   2    5\n",
      "c  3    6\n",
      "   1    7\n",
      "d  2    8\n",
      "   3    9\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Series的层次化索引，索引是一个二维数组，相当于两个索引决定一个值\n",
    "# 有点类似于DataFrame的行索引和列索引\n",
    "s = pd.Series(np.arange(1,10),index=[[\"a\",\"a\",\"a\",\"b\",\"b\",\"c\",\"c\",\"d\",\"d\"],[1,2,3,1,2,3,1,2,3]])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MultiIndex(levels=[['a', 'b', 'c', 'd'], [1, 2, 3]],\n",
      "           labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 1, 2, 0, 1, 2]])\n"
     ]
    }
   ],
   "source": [
    "print(s.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1    1\n",
      "2    2\n",
      "3    3\n",
      "dtype: int64\n",
      "1\n",
      "1    1\n",
      "3    3\n",
      "dtype: int64\n",
      "a  1    1\n",
      "   2    2\n",
      "   3    3\n",
      "c  3    6\n",
      "   1    7\n",
      "dtype: int64\n",
      "b  1    4\n",
      "   2    5\n",
      "c  3    6\n",
      "   1    7\n",
      "d  2    8\n",
      "   3    9\n",
      "dtype: int64\n",
      "     1    2    3\n",
      "a  1.0  2.0  3.0\n",
      "b  4.0  5.0  NaN\n",
      "c  7.0  NaN  6.0\n",
      "d  NaN  8.0  9.0\n"
     ]
    }
   ],
   "source": [
    "#选取外层索引为a的数据\n",
    "print(s['a'])\n",
    "#选取外层索引为a和内层索引为1的数据\n",
    "print(s['a',1])\n",
    "#选取外层索引为a和内层索引为1,3的数据\n",
    "print(s['a'][[1,3]])\n",
    "#层次化索引的切片，包括右端的索引\n",
    "print(s[['a','c']])\n",
    "print(s['b':'d'])\n",
    "#通过unstack方法可以将Series变成一个DataFrame\n",
    "#数据的类型以及数据的输出结构都变成了DataFrame，对于不存在的位置使用NaN填充\n",
    "print(s.unstack())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**DataFrame的层次化索引**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th colspan=\"6\" halign=\"left\">模拟考</th>\n",
       "      <th colspan=\"6\" halign=\"left\">正式考</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>数学</th>\n",
       "      <th>语文</th>\n",
       "      <th>英语</th>\n",
       "      <th>物理</th>\n",
       "      <th>化学</th>\n",
       "      <th>生物</th>\n",
       "      <th>数学</th>\n",
       "      <th>语文</th>\n",
       "      <th>英语</th>\n",
       "      <th>物理</th>\n",
       "      <th>化学</th>\n",
       "      <th>生物</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">期中</th>\n",
       "      <th rowspan=\"2\" valign=\"top\">雷军</th>\n",
       "      <th>测试一</th>\n",
       "      <td>138</td>\n",
       "      <td>57</td>\n",
       "      <td>24</td>\n",
       "      <td>3</td>\n",
       "      <td>77</td>\n",
       "      <td>0</td>\n",
       "      <td>131</td>\n",
       "      <td>116</td>\n",
       "      <td>149</td>\n",
       "      <td>0</td>\n",
       "      <td>66</td>\n",
       "      <td>136</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>53</td>\n",
       "      <td>47</td>\n",
       "      <td>48</td>\n",
       "      <td>123</td>\n",
       "      <td>61</td>\n",
       "      <td>57</td>\n",
       "      <td>32</td>\n",
       "      <td>139</td>\n",
       "      <td>62</td>\n",
       "      <td>22</td>\n",
       "      <td>7</td>\n",
       "      <td>59</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">李斌</th>\n",
       "      <th>测试一</th>\n",
       "      <td>6</td>\n",
       "      <td>58</td>\n",
       "      <td>42</td>\n",
       "      <td>98</td>\n",
       "      <td>65</td>\n",
       "      <td>31</td>\n",
       "      <td>115</td>\n",
       "      <td>109</td>\n",
       "      <td>24</td>\n",
       "      <td>83</td>\n",
       "      <td>3</td>\n",
       "      <td>101</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>121</td>\n",
       "      <td>69</td>\n",
       "      <td>100</td>\n",
       "      <td>47</td>\n",
       "      <td>46</td>\n",
       "      <td>11</td>\n",
       "      <td>85</td>\n",
       "      <td>41</td>\n",
       "      <td>5</td>\n",
       "      <td>37</td>\n",
       "      <td>12</td>\n",
       "      <td>144</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">期末</th>\n",
       "      <th rowspan=\"2\" valign=\"top\">雷军</th>\n",
       "      <th>测试一</th>\n",
       "      <td>126</td>\n",
       "      <td>18</td>\n",
       "      <td>127</td>\n",
       "      <td>15</td>\n",
       "      <td>79</td>\n",
       "      <td>131</td>\n",
       "      <td>1</td>\n",
       "      <td>73</td>\n",
       "      <td>72</td>\n",
       "      <td>104</td>\n",
       "      <td>48</td>\n",
       "      <td>56</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>44</td>\n",
       "      <td>79</td>\n",
       "      <td>86</td>\n",
       "      <td>86</td>\n",
       "      <td>129</td>\n",
       "      <td>116</td>\n",
       "      <td>51</td>\n",
       "      <td>5</td>\n",
       "      <td>85</td>\n",
       "      <td>148</td>\n",
       "      <td>137</td>\n",
       "      <td>138</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">李斌</th>\n",
       "      <th>测试一</th>\n",
       "      <td>67</td>\n",
       "      <td>30</td>\n",
       "      <td>8</td>\n",
       "      <td>125</td>\n",
       "      <td>115</td>\n",
       "      <td>48</td>\n",
       "      <td>134</td>\n",
       "      <td>120</td>\n",
       "      <td>51</td>\n",
       "      <td>115</td>\n",
       "      <td>98</td>\n",
       "      <td>59</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>75</td>\n",
       "      <td>16</td>\n",
       "      <td>123</td>\n",
       "      <td>115</td>\n",
       "      <td>76</td>\n",
       "      <td>9</td>\n",
       "      <td>64</td>\n",
       "      <td>148</td>\n",
       "      <td>77</td>\n",
       "      <td>126</td>\n",
       "      <td>49</td>\n",
       "      <td>94</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           模拟考                          正式考                         \n",
       "            数学  语文   英语   物理   化学   生物   数学   语文   英语   物理   化学   生物\n",
       "期中 雷军 测试一  138  57   24    3   77    0  131  116  149    0   66  136\n",
       "      测试二   53  47   48  123   61   57   32  139   62   22    7   59\n",
       "   李斌 测试一    6  58   42   98   65   31  115  109   24   83    3  101\n",
       "      测试二  121  69  100   47   46   11   85   41    5   37   12  144\n",
       "期末 雷军 测试一  126  18  127   15   79  131    1   73   72  104   48   56\n",
       "      测试二   44  79   86   86  129  116   51    5   85  148  137  138\n",
       "   李斌 测试一   67  30    8  125  115   48  134  120   51  115   98   59\n",
       "      测试二   75  16  123  115   76    9   64  148   77  126   49   94"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.DataFrame(np.random.randint(0,150,size=(8,12)),\n",
    "               columns = pd.MultiIndex.from_product([['模拟考','正式考'],\n",
    "                                                   ['数学','语文','英语','物理','化学','生物']]),\n",
    "               index = pd.MultiIndex.from_product([['期中','期末'],\n",
    "                                                   ['雷军','李斌'],\n",
    "                                                  ['测试一','测试二']]))\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>语文</th>\n",
       "      <th>数学</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">期中</th>\n",
       "      <th rowspan=\"2\" valign=\"top\">雷军</th>\n",
       "      <th>测试一</th>\n",
       "      <td>57</td>\n",
       "      <td>138</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>47</td>\n",
       "      <td>53</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">李斌</th>\n",
       "      <th>测试一</th>\n",
       "      <td>58</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>69</td>\n",
       "      <td>121</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">期末</th>\n",
       "      <th rowspan=\"2\" valign=\"top\">雷军</th>\n",
       "      <th>测试一</th>\n",
       "      <td>18</td>\n",
       "      <td>126</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>79</td>\n",
       "      <td>44</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">李斌</th>\n",
       "      <th>测试一</th>\n",
       "      <td>30</td>\n",
       "      <td>67</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>16</td>\n",
       "      <td>75</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           语文   数学\n",
       "期中 雷军 测试一  57  138\n",
       "      测试二  47   53\n",
       "   李斌 测试一  58    6\n",
       "      测试二  69  121\n",
       "期末 雷军 测试一  18  126\n",
       "      测试二  79   44\n",
       "   李斌 测试一  30   67\n",
       "      测试二  16   75"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['模拟考'][['语文','数学']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "138\n"
     ]
    }
   ],
   "source": [
    "print(data.loc['期中','雷军','测试一']['模拟考','数学'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模拟考  数学    138\n",
      "     语文     57\n",
      "     英语     24\n",
      "     物理      3\n",
      "     化学     77\n",
      "     生物      0\n",
      "正式考  数学    131\n",
      "     语文    116\n",
      "     英语    149\n",
      "     物理      0\n",
      "     化学     66\n",
      "     生物    136\n",
      "Name: (期中, 雷军, 测试一), dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(data.iloc[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>数学</th>\n",
       "      <th>语文</th>\n",
       "      <th>英语</th>\n",
       "      <th>物理</th>\n",
       "      <th>化学</th>\n",
       "      <th>生物</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">期中</th>\n",
       "      <th rowspan=\"2\" valign=\"top\">雷军</th>\n",
       "      <th>测试一</th>\n",
       "      <td>131</td>\n",
       "      <td>116</td>\n",
       "      <td>149</td>\n",
       "      <td>0</td>\n",
       "      <td>66</td>\n",
       "      <td>136</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>32</td>\n",
       "      <td>139</td>\n",
       "      <td>62</td>\n",
       "      <td>22</td>\n",
       "      <td>7</td>\n",
       "      <td>59</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">李斌</th>\n",
       "      <th>测试一</th>\n",
       "      <td>115</td>\n",
       "      <td>109</td>\n",
       "      <td>24</td>\n",
       "      <td>83</td>\n",
       "      <td>3</td>\n",
       "      <td>101</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>85</td>\n",
       "      <td>41</td>\n",
       "      <td>5</td>\n",
       "      <td>37</td>\n",
       "      <td>12</td>\n",
       "      <td>144</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">期末</th>\n",
       "      <th rowspan=\"2\" valign=\"top\">雷军</th>\n",
       "      <th>测试一</th>\n",
       "      <td>1</td>\n",
       "      <td>73</td>\n",
       "      <td>72</td>\n",
       "      <td>104</td>\n",
       "      <td>48</td>\n",
       "      <td>56</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>51</td>\n",
       "      <td>5</td>\n",
       "      <td>85</td>\n",
       "      <td>148</td>\n",
       "      <td>137</td>\n",
       "      <td>138</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">李斌</th>\n",
       "      <th>测试一</th>\n",
       "      <td>134</td>\n",
       "      <td>120</td>\n",
       "      <td>51</td>\n",
       "      <td>115</td>\n",
       "      <td>98</td>\n",
       "      <td>59</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>测试二</th>\n",
       "      <td>64</td>\n",
       "      <td>148</td>\n",
       "      <td>77</td>\n",
       "      <td>126</td>\n",
       "      <td>49</td>\n",
       "      <td>94</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            数学   语文   英语   物理   化学   生物\n",
       "期中 雷军 测试一  131  116  149    0   66  136\n",
       "      测试二   32  139   62   22    7   59\n",
       "   李斌 测试一  115  109   24   83    3  101\n",
       "      测试二   85   41    5   37   12  144\n",
       "期末 雷军 测试一    1   73   72  104   48   56\n",
       "      测试二   51    5   85  148  137  138\n",
       "   李斌 测试一  134  120   51  115   98   59\n",
       "      测试二   64  148   77  126   49   94"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['正式考']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "讲到这里，我们关于pandas模块的学习基本完成，其实在掌握了pandas这8个主要的应用方法就可以灵活的解决很多工作中的数据处理、统计分析等任务。有关更多的pandas介绍，可参考pandas官方文档：htt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
